// 25_lifetimes_constraints.rs
// Rust 生命周期约束教程

fn main() {
    println!("=== Rust 生命周期约束 ===\n");
    
    // 1. 基本生命周期回顾
    println!("1. 基本生命周期回顾");
    
    let string1 = String::from("abc");
    let string2 = String::from("def");
    
    let result = longest(&string1, &string2);
    println!("较长的字符串: {}", result);
    
    // 2. 生命周期约束示例
    println!("\n2. 生命周期约束示例");
    
    let novel = String::from("Call me Ishmael. Some years ago...");
    let first_sentence = novel.split('.').next().expect("Could not find a '.'");
    let i = ImportantExcerpt {
        part: first_sentence,
    };
    println!("重要摘录: {}", i.part);
    
    // 3. 多个生命周期参数
    println!("\n3. 多个生命周期参数");
    
    let x = 5;
    let y = 10;
    let result = multiply_longest(&x, &y, "hello");
    println!("multiply_longest结果: {}", result);
    
    // 4. 高级生命周期约束
    println!("\n4. 高级生命周期约束");
    
    // 创建一个更详细的示例来展示 'a: 'b 约束
    let outer_data = String::from("外部数据");
    let inner_data = String::from("内部数据");
    
    let result = advanced_lifetimes_example(&outer_data, &inner_data);
    println!("高级生命周期示例结果: {}", result);
    
    // 5. 生命周期与泛型结合
    println!("\n5. 生命周期与泛型结合");
    
    let numbers = vec![1, 2, 3, 4, 5];
    let slice = &numbers[..];// 创建一个 slice, 引用了 numbers 的 slice
    let default = 0;
    let result = first_or_default(slice, &default);
    println!("first_or_default结果: {}", result);
    
    // 调用修复后的 first_or_default2 函数
    let empty_vec: Vec<i32> = vec![];
    let empty_slice = &empty_vec[..];
    let default_value = 42;
    let result2 = first_or_default2(empty_slice, &default_value);
    println!("first_or_default2结果: {}", result2);

    // 6. 静态生命周期
    println!("\n6. 静态生命周期");
    
    let static_str: &'static str = "我是一个静态字符串";
    println!("静态字符串: {}", static_str);
    
    let static_ref = get_static_ref();
    println!("静态引用: {}", static_ref);
    
    // 7. 生命周期约束的实际应用
    println!("\n7. 生命周期约束的实际应用");
    
    let data = DataHolder {
        value: 42,
        description: "这是一个数据容器",
    };
    
    let description = data.get_description();
    println!("数据描述: {}", description);
    
    let processed = process_data(&data);
    println!("处理后的数据: {}", processed);
    
    // 8. 多个生命周期参数的复杂示例
    println!("\n8. 多个生命周期参数的复杂示例");
    
    let param1 = String::from("参数1");
    let param2 = String::from("参数2");
    let param3 = String::from("参数3");
    
    let complex_result = complex_lifetimes_example(&param1, &param2, &param3);
    println!("复杂生命周期示例结果: {}", complex_result);
    
    println!("\n生命周期约束确保了引用的有效性，防止悬垂引用，是Rust内存安全的重要保障。");
}

// 基本的生命周期函数示例
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

// 结构体中的生命周期
struct ImportantExcerpt<'a> {
    part: &'a str,
}

// 多个生命周期参数的函数
fn multiply_longest<'a, 'b>(x: &'a i32, y: &'b i32, announcement: &'static str) -> String {
    println!("{}", announcement);
    if x > y {
        format!("较大的值是: {}", x)
    } else {
        format!("较大的值是: {}", y)
    }
}

// 高级生命周期约束 - 'a: 'b 表示'a生命周期至少和'b一样长
fn announce_names<'a, 'b>(name1: &'a str, name2: &'b str) -> String 
where
    'a: 'b,  // 'a生命周期至少和'b一样长
{
    format!("介绍两个人: {} 和 {}", name1, name2)
}

// 修复后的函数调用
fn test_lifetimes() {
    let name1 = String::from("张三");
    let name2 = String::from("李四");
    let introduction = announce_names(&name1, &name2);
    println!("介绍: {}", introduction);
}

// 高级生命周期约束示例
fn advanced_lifetimes_example<'a, 'b>(outer: &'a str, inner: &'b str) -> &'b str
where
    'a: 'b,  // 'a生命周期至少和'b一样长
{
    // 在这个函数中，我们可以安全地返回'inner引用
    // 因为'outer的生命周期至少和'inner一样长
    println!("外部数据: {}", outer);
    inner  // 可以安全返回，因为'outer生命周期 >= 'inner生命周期
}

// 生命周期与泛型结合
fn first_or_default<'a, T>(slice: &'a [T], default: &'a T) -> &'a T {
    slice.get(0).unwrap_or(default)
}
// 生命周期与泛型结合 - 修复版本
fn first_or_default2<'b, T>(slice: &'b [T], default: &'b T) -> &'b T {
    slice.get(0).unwrap_or(default)
}

// 静态生命周期示例
fn get_static_ref() -> &'static str {
    "这是一个静态引用"
}

// 实际应用中的结构体
struct DataHolder<'a> {
    value: i32,
    description: &'a str,
}

impl<'a> DataHolder<'a> {
    fn get_description(&self) -> &str {
        self.description
    }
}

fn process_data<'a>(data: &'a DataHolder) -> String {
    format!("处理数据: {} - 值: {}", data.description, data.value)
}

// 多个生命周期参数的复杂示例
fn complex_lifetimes_example<'a, 'b, 'c>(
    param1: &'a str, 
    param2: &'b str, 
    param3: &'c str
) -> &'a str 
where
    'b: 'a,  // 'b生命周期至少和'a一样长
    'c: 'a,  // 'c生命周期至少和'a一样长
{
    println!("参数2: {}", param2);
    println!("参数3: {}", param3);
    param1  // 返回'a生命周期的引用
}
